home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / octa209s.zip / octave-2.09 / liboctave / mx-inlines.cc < prev    next >
C/C++ Source or Header  |  1996-10-12  |  15KB  |  846 lines
  1. // Helper functions for matrix classes.
  2. /*
  3.  
  4. Copyright (C) 1996 John W. Eaton
  5.  
  6. This file is part of Octave.
  7.  
  8. Octave is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 2, or (at your option) any
  11. later version.
  12.  
  13. Octave is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with Octave; see the file COPYING.  If not, write to the Free
  20. Software Foundation, 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21.  
  22. */
  23.  
  24. #include "oct-cmplx.h"
  25.  
  26. // But first, some helper functions...
  27.  
  28. // XXX FIXME XXX -- these need to be done with templates...
  29.  
  30. static inline bool
  31. equal (const char *x, const char *y, int len)
  32. {
  33.   for (int i = 0; i < len; i++)
  34.     if (x[i] != y[i])
  35.       return false;
  36.  
  37.   return true;
  38. }
  39.  
  40. static inline double *
  41. add (const double *d, int len, double s)
  42. {
  43.   double *result = 0;
  44.   if (len > 0)
  45.     {
  46.       result = new double [len];
  47.       for (int i = 0; i < len; i++)
  48.     result[i] = d[i] + s;
  49.     }
  50.   return result;
  51. }
  52.  
  53. static inline double *
  54. subtract (const double *d, int len, double s)
  55. {
  56.   double *result = 0;
  57.   if (len > 0)
  58.     {
  59.       result = new double [len];
  60.       for (int i = 0; i < len; i++)
  61.     result[i] = d[i] - s;
  62.     }
  63.   return result;
  64. }
  65.  
  66. static inline double *
  67. subtract (double s, const double *d, int len)
  68. {
  69.   double *result = 0;
  70.   if (len > 0)
  71.     {
  72.       result = new double [len];
  73.       for (int i = 0; i < len; i++)
  74.     result[i] = s - d[i];
  75.     }
  76.   return result;
  77. }
  78.  
  79. static inline double *
  80. multiply (const double *d, int len, double s)
  81. {
  82.   double *result = 0;
  83.   if (len > 0)
  84.     {
  85.       result = new double [len];
  86.       for (int i = 0; i < len; i++)
  87.     result[i] = d[i] * s;
  88.     }
  89.   return result;
  90. }
  91.  
  92. static inline double *
  93. divide (const double *d, int len, double s)
  94. {
  95.   double *result = 0;
  96.   if (len > 0)
  97.     {
  98.       result = new double [len];
  99.       for (int i = 0; i < len; i++)
  100.     result[i] = d[i] / s;
  101.     }
  102.   return result;
  103. }
  104.  
  105. static inline double *
  106. divide (double s, const double *d, int len)
  107. {
  108.   double *result = 0;
  109.   if (len > 0)
  110.     {
  111.       result = new double [len];
  112.       for (int i = 0; i < len; i++)
  113.     result[i] = s / d[i];
  114.     }
  115.   return result;
  116. }
  117.  
  118. static inline double *
  119. add (const double *x, const double *y, int len)
  120. {
  121.   double *result = 0;
  122.   if (len > 0)
  123.     {
  124.       result = new double [len];
  125.       for (int i = 0; i < len; i++)
  126.     result[i] = x[i] + y[i];
  127.     }
  128.   return result;
  129. }
  130.  
  131. static inline double *
  132. subtract (const double *x, const double *y, int len)
  133. {
  134.   double *result = 0;
  135.   if (len > 0)
  136.     {
  137.       result = new double [len];
  138.       for (int i = 0; i < len; i++)
  139.     result[i] = x[i] - y[i];
  140.     }
  141.   return result;
  142. }
  143.  
  144. static inline double *
  145. multiply (const double *x, const double *y, int len)
  146. {
  147.   double *result = 0;
  148.   if (len > 0)
  149.     {
  150.       result = new double [len];
  151.       for (int i = 0; i < len; i++)
  152.     result[i] = x[i] * y[i];
  153.     }
  154.   return result;
  155. }
  156.  
  157. static inline double *
  158. divide (const double *x, const double *y, int len)
  159. {
  160.   double *result = 0;
  161.   if (len > 0)
  162.     {
  163.       result = new double [len];
  164.       for (int i = 0; i < len; i++)
  165.     result[i] = x[i] / y[i];
  166.     }
  167.   return result;
  168. }
  169.  
  170. static inline double *
  171. add2 (double *x, const double *y, int len)
  172. {
  173.   for (int i = 0; i < len; i++)
  174.     x[i] += y[i];
  175.   return x;
  176. }
  177.  
  178. static inline double *
  179. subtract2 (double *x, const double *y, int len)
  180. {
  181.   for (int i = 0; i < len; i++)
  182.     x[i] -= y[i];
  183.   return x;
  184. }
  185.  
  186. static inline double *
  187. negate (const double *d, int len)
  188. {
  189.   double *result = 0;
  190.   if (len > 0)
  191.     {
  192.       result = new double [len];
  193.       for (int i = 0; i < len; i++)
  194.     result[i] = -d[i];
  195.     }
  196.   return result;
  197. }
  198.  
  199. static inline void
  200. copy (double *d, int len, double s)
  201. {
  202.   for (int i = 0; i < len; i++)
  203.     d[i] = s;
  204. }
  205.  
  206. static inline void
  207. copy (double *x, const double *y, int len)
  208. {
  209.   for (int i = 0; i < len; i++)
  210.     x[i] = y[i];
  211. }
  212.  
  213. static inline double *
  214. dup (const double *x, int len)
  215. {
  216.   double *retval = 0;
  217.   if (len > 0)
  218.     {
  219.       retval = new double [len];
  220.       for (int i = 0; i < len; i++)
  221.     retval[i] = x[i];
  222.     }
  223.   return retval;
  224. }
  225.  
  226. static inline int
  227. equal (const double *x, const double *y, int len)
  228. {
  229.   for (int i = 0; i < len; i++)
  230.     if (x[i] != y[i])
  231.       return 0;
  232.   return 1;
  233. }
  234.  
  235. // And some for Complex too...
  236.  
  237. static inline Complex *
  238. add (const Complex *d, int len, Complex s)
  239. {
  240.   Complex *result = 0;
  241.   if (len > 0)
  242.     {
  243.       result = new Complex [len];
  244.       for (int i = 0; i < len; i++)
  245.     result[i] = d[i] + s;
  246.     }
  247.   return result;
  248. }
  249.  
  250. static inline Complex *
  251. add (Complex s, const Complex *d, int len)
  252. {
  253.   Complex *result = 0;
  254.   if (len > 0)
  255.     {
  256.       result = new Complex [len];
  257.       for (int i = 0; i < len; i++)
  258.     result[i] = s + d[i];
  259.     }
  260.   return result;
  261. }
  262.  
  263. static inline Complex *
  264. subtract (const Complex *d, int len, Complex s)
  265. {
  266.   Complex *result = 0;
  267.   if (len > 0)
  268.     {
  269.       result = new Complex [len];
  270.       for (int i = 0; i < len; i++)
  271.     result[i] = d[i] - s;
  272.     }
  273.   return result;
  274. }
  275.  
  276. static inline Complex *
  277. subtract (Complex s, const Complex *d, int len)
  278. {
  279.   Complex *result = 0;
  280.   if (len > 0)
  281.     {
  282.       result = new Complex [len];
  283.       for (int i = 0; i < len; i++)
  284.     result[i] = s - d[i];
  285.     }
  286.   return result;
  287. }
  288.  
  289. static inline Complex *
  290. multiply (const Complex *d, int len, Complex s)
  291. {
  292.   Complex *result = 0;
  293.   if (len > 0)
  294.     {
  295.       result = new Complex [len];
  296.       for (int i = 0; i < len; i++)
  297.     result[i] = d[i] * s;
  298.     }
  299.   return result;
  300. }
  301.  
  302. static inline Complex *
  303. multiply (Complex s, const Complex *d, int len)
  304. {
  305.   Complex *result = 0;
  306.   if (len > 0)
  307.     {
  308.       result = new Complex [len];
  309.       for (int i = 0; i < len; i++)
  310.     result[i] = s * d[i];
  311.     }
  312.   return result;
  313. }
  314.  
  315. static inline Complex *
  316. divide (const Complex *d, int len, Complex s)
  317. {
  318.   Complex *result = 0;
  319.   if (len > 0)
  320.     {
  321.       result = new Complex [len];
  322.       for (int i = 0; i < len; i++)
  323.     result[i] = d[i] / s;
  324.     }
  325.   return result;
  326. }
  327.  
  328. static inline Complex *
  329. divide (Complex s, const Complex *d, int len)
  330. {
  331.   Complex *result = 0;
  332.   if (len > 0)
  333.     {
  334.       result = new Complex [len];
  335.       for (int i = 0; i < len; i++)
  336.     result[i] = s / d[i];
  337.     }
  338.   return result;
  339. }
  340.  
  341. static inline Complex *
  342. add (const Complex *x, const Complex *y, int len)
  343. {
  344.   Complex *result = 0;
  345.   if (len > 0)
  346.     {
  347.       result = new Complex [len];
  348.       for (int i = 0; i < len; i++)
  349.     result[i] = x[i] + y[i];
  350.     }
  351.   return result;
  352. }
  353.  
  354. static inline Complex *
  355. subtract (const Complex *x, const Complex *y, int len)
  356. {
  357.   Complex *result = 0;
  358.   if (len > 0)
  359.     {
  360.       result = new Complex [len];
  361.       for (int i = 0; i < len; i++)
  362.     result[i] = x[i] - y[i];
  363.     }
  364.   return result;
  365. }
  366.  
  367. static inline Complex *
  368. multiply (const Complex *x, const Complex *y, int len)
  369. {
  370.   Complex *result = 0;
  371.   if (len > 0)
  372.     {
  373.       result = new Complex [len];
  374.       for (int i = 0; i < len; i++)
  375.     result[i] = x[i] * y[i];
  376.     }
  377.   return result;
  378. }
  379.  
  380. static inline Complex *
  381. divide (const Complex *x, const Complex *y, int len)
  382. {
  383.   Complex *result = 0;
  384.   if (len > 0)
  385.     {
  386.       result = new Complex [len];
  387.       for (int i = 0; i < len; i++)
  388.     result[i] = x[i] / y[i];
  389.     }
  390.   return result;
  391. }
  392.  
  393. static inline Complex *
  394. add2 (Complex *x, const Complex *y, int len)
  395. {
  396.   for (int i = 0; i < len; i++)
  397.     x[i] += y[i];
  398.   return x;
  399. }
  400.  
  401. static inline Complex *
  402. subtract2 (Complex *x, const Complex *y, int len)
  403. {
  404.   for (int i = 0; i < len; i++)
  405.     x[i] -= y[i];
  406.   return x;
  407. }
  408.  
  409. static inline Complex *
  410. negate (const Complex *d, int len)
  411. {
  412.   Complex *result = 0;
  413.   if (len > 0)
  414.     {
  415.       result = new Complex [len];
  416.       for (int i = 0; i < len; i++)
  417.     result[i] = -d[i];
  418.     }
  419.   return result;
  420. }
  421.  
  422. static inline double *
  423. not (const Complex *d, int len)
  424. {
  425.   double *result = 0;
  426.   if (len > 0)
  427.     {
  428.       result = new double [len];
  429.       for (int i = 0; i < len; i++)
  430.     result[i] = (d[i] == 0.0);
  431.     }
  432.   return result;
  433. }
  434.  
  435. static inline void
  436. copy (Complex *d, int len, Complex s)
  437. {
  438.   for (int i = 0; i < len; i++)
  439.     d[i] = s;
  440. }
  441.  
  442. static inline void
  443. copy (Complex *x, const Complex *y, int len)
  444. {
  445.   for (int i = 0; i < len; i++)
  446.     x[i] = y[i];
  447. }
  448.  
  449. static inline Complex *
  450. dup (const Complex *x, int len)
  451. {
  452.   Complex *retval = 0;
  453.   if (len > 0)
  454.     {
  455.       retval = new Complex [len];
  456.       for (int i = 0; i < len; i++)
  457.     retval[i] = x[i];
  458.     }
  459.   return retval;
  460. }
  461.  
  462. static inline Complex *
  463. make_complex (const double *x, int len)
  464. {
  465.   Complex *retval = 0;
  466.   if (len > 0)
  467.     {
  468.       retval = new Complex [len];
  469.       for (int i = 0; i < len; i++)
  470.     retval[i] = x[i];
  471.     }
  472.   return retval;
  473. }
  474.  
  475. static inline Complex *
  476. conj_dup (const Complex *x, int len)
  477. {
  478.   Complex *retval = 0;
  479.   if (len > 0)
  480.     {
  481.       retval = new Complex [len];
  482.       for (int i = 0; i < len; i++)
  483.     retval[i] = conj (x[i]);
  484.     }
  485.   return retval;
  486. }
  487.  
  488. static inline double *
  489. real_dup (const Complex *x, int len)
  490. {
  491.   double *retval = 0;
  492.   if (len > 0)
  493.     {
  494.       retval = new double [len];
  495.       for (int i = 0; i < len; i++)
  496.     retval[i] = real (x[i]);
  497.     }
  498.   return retval;
  499. }
  500.  
  501. static inline double *
  502. imag_dup (const Complex *x, int len)
  503. {
  504.   double *retval = 0;
  505.   if (len > 0)
  506.     {
  507.       retval = new double [len];
  508.       for (int i = 0; i < len; i++)
  509.     retval[i] = imag (x[i]);
  510.     }
  511.   return retval;
  512. }
  513.  
  514. static inline int
  515. equal (const Complex *x, const Complex *y, int len)
  516. {
  517.   for (int i = 0; i < len; i++)
  518.     if (x[i] != y[i])
  519.       return 0;
  520.   return 1;
  521. }
  522.  
  523. // And still some more for mixed Complex/double operations...
  524.  
  525. static inline Complex *
  526. add (const Complex *d, int len, double s)
  527. {
  528.   Complex *result = 0;
  529.   if (len > 0)
  530.     {
  531.       result = new Complex [len];
  532.       for (int i = 0; i < len; i++)
  533.     result[i] = d[i] + s;
  534.     }
  535.   return result;
  536. }
  537.  
  538. static inline Complex *
  539. add (const double *d, int len, Complex s)
  540. {
  541.   Complex *result = 0;
  542.   if (len > 0)
  543.     {
  544.       result = new Complex [len];
  545.       for (int i = 0; i < len; i++)
  546.     result[i] = d[i] + s;
  547.     }
  548.   return result;
  549. }
  550.  
  551. static inline Complex *
  552. add (double s, const Complex *d, int len)
  553. {
  554.   Complex *result = 0;
  555.   if (len > 0)
  556.     {
  557.       result = new Complex [len];
  558.       for (int i = 0; i < len; i++)
  559.     result[i] = s + d[i];
  560.     }
  561.   return result;
  562. }
  563.  
  564. static inline Complex *
  565. add (Complex s, const double *d, int len)
  566. {
  567.   Complex *result = 0;
  568.   if (len > 0)
  569.     {
  570.       result = new Complex [len];
  571.       for (int i = 0; i < len; i++)
  572.     result[i] = s + d[i];
  573.     }
  574.   return result;
  575. }
  576.  
  577. static inline Complex *
  578. subtract (const Complex *d, int len, double s)
  579. {
  580.   Complex *result = 0;
  581.   if (len > 0)
  582.     {
  583.       result = new Complex [len];
  584.       for (int i = 0; i < len; i++)
  585.     result[i] = d[i] - s;
  586.     }
  587.   return result;
  588. }
  589.  
  590. static inline Complex *
  591. subtract (const double *d, int len, Complex s)
  592. {
  593.   Complex *result = 0;
  594.   if (len > 0)
  595.     {
  596.       result = new Complex [len];
  597.       for (int i = 0; i < len; i++)
  598.     result[i] = d[i] - s;
  599.     }
  600.   return result;
  601. }
  602.  
  603. static inline Complex *
  604. subtract (double s, const Complex *d, int len)
  605. {
  606.   Complex *result = 0;
  607.   if (len > 0)
  608.     {
  609.       result = new Complex [len];
  610.       for (int i = 0; i < len; i++)
  611.     result[i] = s - d[i];
  612.     }
  613.   return result;
  614. }
  615.  
  616. static inline Complex *
  617. subtract (Complex s, const double *d, int len)
  618. {
  619.   Complex *result = 0;
  620.   if (len > 0)
  621.     {
  622.       result = new Complex [len];
  623.       for (int i = 0; i < len; i++)
  624.     result[i] = s - d[i];
  625.     }
  626.   return result;
  627. }
  628.  
  629. static inline Complex *
  630. multiply (const Complex *d, int len, double s)
  631. {
  632.   Complex *result = 0;
  633.   if (len > 0)
  634.     {
  635.       result = new Complex [len];
  636.       for (int i = 0; i < len; i++)
  637.     result[i] = d[i] * s;
  638.     }
  639.   return result;
  640. }
  641.  
  642. static inline Complex *
  643. multiply (const double *d, int len, Complex s)
  644. {
  645.   Complex *result = 0;
  646.   if (len > 0)
  647.     {
  648.       result = new Complex [len];
  649.       for (int i = 0; i < len; i++)
  650.     result[i] = d[i] * s;
  651.     }
  652.   return result;
  653. }
  654.  
  655. static inline Complex *
  656. divide (const Complex *d, int len, double s)
  657. {
  658.   Complex *result = 0;
  659.   if (len > 0)
  660.     {
  661.       result = new Complex [len];
  662.       for (int i = 0; i < len; i++)
  663.     result[i] = d[i] / s;
  664.     }
  665.   return result;
  666. }
  667.  
  668. static inline Complex *
  669. divide (const double *d, int len, Complex s)
  670. {
  671.   Complex *result = 0;
  672.   if (len > 0)
  673.     {
  674.       result = new Complex [len];
  675.       for (int i = 0; i < len; i++)
  676.     result[i] = d[i] / s;
  677.     }
  678.   return result;
  679. }
  680.  
  681. static inline Complex *
  682. divide (double s, const Complex *d, int len)
  683. {
  684.   Complex *result = 0;
  685.   if (len > 0)
  686.     {
  687.       result = new Complex [len];
  688.       for (int i = 0; i < len; i++)
  689.     result[i] = s / d[i];
  690.     }
  691.   return result;
  692. }
  693.  
  694. static inline Complex *
  695. divide (Complex s, const double *d, int len)
  696. {
  697.   Complex *result = 0;
  698.   if (len > 0)
  699.     {
  700.       result = new Complex [len];
  701.       for (int i = 0; i < len; i++)
  702.     result[i] = s / d[i];
  703.     }
  704.   return result;
  705. }
  706.  
  707. static inline Complex *
  708. add (const Complex *x, const double *y, int len)
  709. {
  710.   Complex *result = 0;
  711.   if (len > 0)
  712.     {
  713.       result = new Complex [len];
  714.       for (int i = 0; i < len; i++)
  715.     result[i] = x[i] + y[i];
  716.     }
  717.   return result;
  718. }
  719.  
  720. static inline Complex *
  721. add (const double *x, const Complex *y, int len)
  722. {
  723.   Complex *result = 0;
  724.   if (len > 0)
  725.     {
  726.       result = new Complex [len];
  727.       for (int i = 0; i < len; i++)
  728.     result[i] = x[i] + y[i];
  729.     }
  730.   return result;
  731. }
  732.  
  733. static inline Complex *
  734. subtract (const Complex *x, const double *y, int len)
  735. {
  736.   Complex *result = 0;
  737.   if (len > 0)
  738.     {
  739.       result = new Complex [len];
  740.       for (int i = 0; i < len; i++)
  741.     result[i] = x[i] - y[i];
  742.     }
  743.   return result;
  744. }
  745.  
  746. static inline Complex *
  747. subtract (const double *x, const Complex *y, int len)
  748. {
  749.   Complex *result = 0;
  750.   if (len > 0)
  751.     {
  752.       result = new Complex [len];
  753.       for (int i = 0; i < len; i++)
  754.     result[i] = x[i] - y[i];
  755.     }
  756.   return result;
  757. }
  758.  
  759. static inline Complex *
  760. multiply (const Complex *x, const double *y, int len)
  761. {
  762.   Complex *result = 0;
  763.   if (len > 0)
  764.     {
  765.       result = new Complex [len];
  766.       for (int i = 0; i < len; i++)
  767.     result[i] = x[i] * y[i];
  768.     }
  769.   return result;
  770. }
  771.  
  772. static inline Complex *
  773. multiply (const double *x, const Complex *y, int len)
  774. {
  775.   Complex *result = 0;
  776.   if (len > 0)
  777.     {
  778.       result = new Complex [len];
  779.       for (int i = 0; i < len; i++)
  780.     result[i] = x[i] * y[i];
  781.     }
  782.   return result;
  783. }
  784.  
  785. static inline Complex *
  786. divide (const Complex *x, const double *y, int len)
  787. {
  788.   Complex *result = 0;
  789.   if (len > 0)
  790.     {
  791.       result = new Complex [len];
  792.       for (int i = 0; i < len; i++)
  793.     result[i] = x[i] / y[i];
  794.     }
  795.   return result;
  796. }
  797.  
  798. static inline Complex *
  799. divide (const double *x, const Complex *y, int len)
  800. {
  801.   Complex *result = 0;
  802.   if (len > 0)
  803.     {
  804.       result = new Complex [len];
  805.       for (int i = 0; i < len; i++)
  806.     result[i] = x[i] / y[i];
  807.     }
  808.   return result;
  809. }
  810.  
  811. static inline Complex *
  812. add2 (Complex *x, const double *y, int len)
  813. {
  814.   for (int i = 0; i < len; i++)
  815.     x[i] += y[i];
  816.   return x;
  817. }
  818.  
  819. static inline Complex *
  820. subtract2 (Complex *x, const double *y, int len)
  821. {
  822.   for (int i = 0; i < len; i++)
  823.     x[i] -= y[i];
  824.   return x;
  825. }
  826.  
  827. static inline void
  828. copy (Complex *d, int len, double s)
  829. {
  830.   for (int i = 0; i < len; i++)
  831.     d[i] = s;
  832. }
  833.  
  834. static inline void
  835. copy (Complex *x, const double *y, int len)
  836. {
  837.   for (int i = 0; i < len; i++)
  838.     x[i] = y[i];
  839. }
  840.  
  841. /*
  842. ;;; Local Variables: ***
  843. ;;; mode: C++ ***
  844. ;;; End: ***
  845. */
  846.